平衡二叉树AVLTree

最新推荐文章于 2022-05-10 11:03:50 发布
最新推荐文章于 2022-05-10 11:03:50 发布
阅读量291 收藏 1
点赞数
分类专栏： 数据结构 文章标签： 数据结构 平衡二叉树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/NineZc/article/details/79080101
版权 
// AVLTree.cpp : 定义控制台应用程序的入口点。
//
#include"stdafx.h"
#include <iostream>
using namespace std;
template <class T>
struct AVLTreeNode
{
    T data;//平衡二叉树结点值
    int BF;//结点平衡因子
           //平衡二叉树结点左右孩子指针和父结点指针
    AVLTreeNode *pLChild, *pRChild, *pParent;
};
template <class T>
class AVLTree
{
public:
    AVLTree() { pAVLTreeRoot = NULL; };
    virtual ~AVLTree() { DestroyAVLTree(pAVLTreeRoot); };
    void InsertAVLTreeNode(int vAVLTNValue);//AVL 树插入关键字函数
    int InsertAVLTreeNode(AVLTreeNode<T> *&vAVLTreeRoot, int vBTNValue, bool &vHeight);//重载 AVL 树插入关键字函数
    void DeleteAVLTreeNode(int vAVLTNValue);//AVL 树删除关键字函数
    int DeleteAVLTreeNode(AVLTreeNode<T> *&vPAVLTreeNode, int vAVLTNValue);//重载 AVL 树删除关键字函数
    void DestroyAVLTree(AVLTreeNode<T> *&vPAVLTreeNode);//销毁 AVL 树
    void LL_Rotate(AVLTreeNode<T> *&vAVLTreeNode);//LL 型
    void LR_Rotate(AVLTreeNode<T> *&vAVLTreeNode);//LR 型
    void RR_Rotate(AVLTreeNode<T> *&vAVLTreeNode);//RR 型
    void RL_Rotate(AVLTreeNode<T> *&vAVLTreeNode);//RL 型
    int LeftBalance(AVLTreeNode<T> *&vAVLTreeNode);//左平衡处理函数
    int RightBalance(AVLTreeNode<T> *&vAVLTreeNode);//右平衡处理函数
    int FindSuccessor(AVLTreeNode<T> *&vPAVLTreeNode_P, AVLTreeNode<T> *&vPAVLTreeNode_Q);//查找被删除关键字的替代结点函数
    void PrintAVLTree(AVLTreeNode<T>* vAVLTreeNode);//重载中序输出 AVL 树
    void PrintAVLTree();//中序输出 AVL 树
    void LeftHorzShow(AVLTreeNode<T>* vAVLTreeNode, int nLayer);//重载横向输出 AVL 树
    void LeftHorzShow();//横向输出 AVL 树
private:
    AVLTreeNode<T>* pAVLTreeRoot;//平衡二叉树根结点指针
    int searchValue;//AVL 树待查找值
    typedef enum { RH = -1, EH = 0, LH = 1 };//AVL 树常量
};
template<class T>
void AVLTree<T>::DestroyAVLTree(AVLTreeNode<T> *&vPAVLTreeNode)
{
    if (vPAVLTreeNode != NULL) {
        DestroyAVLTree(vPAVLTreeNode->pLChild);
        DestroyAVLTree(vPAVLTreeNode->pRChild);
        delete vPAVLTreeNode;
    }
}
template<class T>
void AVLTree<T>::InsertAVLTreeNode(int vAVLTNValue)
{
    bool tHeight;
    InsertAVLTreeNode(pAVLTreeRoot, vAVLTNValue, tHeight);
}
template<class T>
int AVLTree<T>::InsertAVLTreeNode(AVLTreeNode<T> *&vAVLTreeRoot, int vBTNValue,
    bool &vHeight)
{
    if (!vAVLTreeRoot)
    {//如果为空树则创建一个结点
        vAVLTreeRoot = new AVLTreeNode<T>();
        vAVLTreeRoot->data = vBTNValue;
        vAVLTreeRoot->pLChild = NULL;
        vAVLTreeRoot->pRChild = NULL;
        vAVLTreeRoot->pParent = NULL;
        vAVLTreeRoot->BF = 0;
        vHeight = true;
        return 1;
    }
    else
    {
        if (vAVLTreeRoot->data == vBTNValue)
        {
            vHeight = false; return 0;
        }//结点已存在,不应再插入
        if (vAVLTreeRoot->data > vBTNValue)
        {//应插入左子树
            if (!InsertAVLTreeNode(vAVLTreeRoot->pLChild, vBTNValue, vHeight))
                return 0;
            if (vHeight)
            {//如果左子树变高,依据 T 的平衡因子操作
                switch (vAVLTreeRoot->BF)
                {
                case LH://T 的平衡因子变为 2,需作左平衡处理
                    LeftBalance(vAVLTreeRoot);
                    vHeight = false;
                    break;
                case EH:
                    vAVLTreeRoot->BF = 1;
                    vHeight = true;
                    break;
                case RH:
                    vHeight = false;
                    vAVLTreeRoot->BF = 0;
                    break;
                }//switch
            }//if
        }//if
        else
        {//插在右子树
            if (!InsertAVLTreeNode(vAVLTreeRoot->pRChild, vBTNValue, vHeight))
                return 0;
            if (vHeight)
            {
                switch (vAVLTreeRoot->BF)
                {//如果右子树变高
                case LH:
                    vAVLTreeRoot->BF = 0;
                    vHeight = false;
                    break;
                case EH:
                    vAVLTreeRoot->BF = -1;
                    vHeight = true;
                    break;
                case RH://平衡因子变成-2,作右平衡处理
                    RightBalance(vAVLTreeRoot);
                    vHeight = false;
                    break;
                }//switch
            }//if
        }//else
        return 1;
    }//else
    return 1;
}
template<class T>
int AVLTree<T>::LeftBalance(AVLTreeNode<T>*&vAVLTreeNode)
{
    if (vAVLTreeNode->pLChild&&vAVLTreeNode->pLChild->BF == LH)
        LL_Rotate(vAVLTreeNode);
    else if (vAVLTreeNode->pLChild&&vAVLTreeNode->pLChild->BF == RH)
        LR_Rotate(vAVLTreeNode);
    return 2;
}
template<class T>
int AVLTree<T>::RightBalance(AVLTreeNode<T>*&vAVLTreeNode)
{
    if (vAVLTreeNode->pRChild&&vAVLTreeNode->pRChild->BF == LH)
        RL_Rotate(vAVLTreeNode);
    else if (vAVLTreeNode->pRChild&&vAVLTreeNode->pRChild->BF == RH)
        RR_Rotate(vAVLTreeNode);
    return 2;
}

template<class T>
void AVLTree<T>::LL_Rotate(AVLTreeNode<T> *&vAVLTreeNode)
{
    AVLTreeNode<T>* tCurAVLTreeNode = vAVLTreeNode->pLChild;
    vAVLTreeNode->pLChild = tCurAVLTreeNode->pRChild;
    tCurAVLTreeNode->pRChild = vAVLTreeNode;
    switch (tCurAVLTreeNode->BF) {
    case LH:
        vAVLTreeNode->BF = EH;
        tCurAVLTreeNode->BF = EH;
        break;
    case EH:
        vAVLTreeNode->BF = LH;
        tCurAVLTreeNode->BF = RH;
        break;
    }
    vAVLTreeNode = tCurAVLTreeNode;
}
template<class T>
void AVLTree<T>::RR_Rotate(AVLTreeNode<T> *&vAVLTreeNode)
{
    //实现 RR 旋转
    AVLTreeNode<T>* tCurAVLTreeNode = vAVLTreeNode->pRChild;
    vAVLTreeNode->pRChild = tCurAVLTreeNode->pLChild;
    tCurAVLTreeNode->pLChild = vAVLTreeNode;
    switch (tCurAVLTreeNode->BF)
    {
    case RH:
        vAVLTreeNode->BF = EH;
        tCurAVLTreeNode->BF = EH;
        break;
    case EH:
        vAVLTreeNode->BF = RH;
        tCurAVLTreeNode->BF = LH;
        break;
    }
    vAVLTreeNode = tCurAVLTreeNode;

}
template<class T>
void AVLTree<T>::LR_Rotate(AVLTreeNode<T> *&vAVLTreeNode)
{
    //实现 LR 旋转
    AVLTreeNode<T>*tAVLTreeNode_P = vAVLTreeNode->pLChild;
    AVLTreeNode<T>*tAVLTreeNode_Q = tAVLTreeNode_P->pRChild;
    tAVLTreeNode_P->pRChild = tAVLTreeNode_Q->pLChild;
    tAVLTreeNode_Q->pLChild = tAVLTreeNode_P;
    vAVLTreeNode->pLChild = tAVLTreeNode_Q->pRChild;
    tAVLTreeNode_Q->pLChild = vAVLTreeNode;
    switch (tAVLTreeNode_Q->BF)
    {
    case RH:
        tAVLTreeNode_P->BF = LH;
        vAVLTreeNode->BF = EH;
        break;
    case EH:
        tAVLTreeNode_P->BF = EH;
        vAVLTreeNode->BF = EH;
        break;
    case LH:
        tAVLTreeNode_P->BF = EH;
        vAVLTreeNode->BF = RH;
        break;
    }
    tAVLTreeNode_Q->BF = EH;
    vAVLTreeNode = tAVLTreeNode_Q;

}
template<class T>
void AVLTree<T>::RL_Rotate(AVLTreeNode<T> *&vAVLTreeNode)
{
    AVLTreeNode<T>* tAVLTreeNode_P = vAVLTreeNode->pRChild;
    AVLTreeNode<T>* tAVLTreeNode_Q = tAVLTreeNode_P->pLChild;
    tAVLTreeNode_P->pLChild = tAVLTreeNode_Q->pRChild;
    tAVLTreeNode_Q->pRChild = tAVLTreeNode_P;
    vAVLTreeNode->pRChild = tAVLTreeNode_Q->pLChild;
    tAVLTreeNode_Q->pLChild = vAVLTreeNode;
    switch (tAVLTreeNode_Q->BF) {
    case LH:
        tAVLTreeNode_P->BF = RH;
        vAVLTreeNode->BF = EH;
        break;
    case EH:
        tAVLTreeNode_P->BF = EH;
        vAVLTreeNode->BF = EH;
        break;
    case RH:
        tAVLTreeNode_P->BF = EH;
        vAVLTreeNode->BF = LH;
        break;
    }
    tAVLTreeNode_Q->BF = EH;
    vAVLTreeNode = tAVLTreeNode_Q;
}
template<class T>
void AVLTree<T>::DeleteAVLTreeNode(int vAVLTNValue)
{
    DeleteAVLTreeNode(pAVLTreeRoot, vAVLTNValue);
}
template<class T>
int AVLTree<T>::DeleteAVLTreeNode(AVLTreeNode<T> *&vPAVLTreeRoot,
    int vAVLTNValue)
{
    int tStatus;
    if (vPAVLTreeRoot == NULL) return 0;
    if (vPAVLTreeRoot->data > vAVLTNValue) {
        tStatus = DeleteAVLTreeNode(vPAVLTreeRoot->pLChild, vAVLTNValue);
        if (tStatus < 2) return tStatus;
        switch (vPAVLTreeRoot->BF) {
        case LH:
            vPAVLTreeRoot->BF = 0;
            return 2;
        case EH:
            vPAVLTreeRoot->BF = -1;
            return 1;
        case RH:
            return RightBalance(vPAVLTreeRoot);
        }
    }
    if (vPAVLTreeRoot->data < vAVLTNValue) {
        tStatus = DeleteAVLTreeNode(vPAVLTreeRoot->pRChild, vAVLTNValue);
        if (tStatus < 2) return tStatus;
        switch (vPAVLTreeRoot->BF) {
        case RH:
            vPAVLTreeRoot->BF = 0;
            return 2;
        case EH:
            vPAVLTreeRoot->BF = 1;
            return 1;
        case LH:
            return LeftBalance(vPAVLTreeRoot);
        }
    }
    else {
        AVLTreeNode<T> *tCurAVLTreeNode = vPAVLTreeRoot;
        if (vPAVLTreeRoot->pLChild == NULL) {
            vPAVLTreeRoot = vPAVLTreeRoot->pRChild;
            tStatus = 2;
        }
        else
            if (vPAVLTreeRoot->pRChild == NULL) {
                vPAVLTreeRoot = vPAVLTreeRoot->pLChild;
                tStatus = 2;
            }
            else {
                tStatus = FindSuccessor(tCurAVLTreeNode,
                    vPAVLTreeRoot->pRChild);
                if (tStatus < 2) return tStatus;
                switch (vPAVLTreeRoot->BF) {
                case RH:
                    vPAVLTreeRoot->BF = 0;
                    return 2;
                case EH:
                    vPAVLTreeRoot->BF = 1;
                    return 1;
                case LH:
                    return LeftBalance(vPAVLTreeRoot);
                }
            }
            delete tCurAVLTreeNode;
            return tStatus;
    }
    return 0;
}
template<class T>
int AVLTree<T>::FindSuccessor(AVLTreeNode<T> *&vPAVLTreeNode_P,
    AVLTreeNode<T> *&vPAVLTreeNode_Q)
{
    int tStatus;
    if (vPAVLTreeNode_Q->pLChild) {
        tStatus = FindSuccessor(vPAVLTreeNode_P, vPAVLTreeNode_Q->pLChild);
        if (tStatus < 2) return tStatus;
        switch (vPAVLTreeNode_Q->BF) {
        case LH:
            vPAVLTreeNode_Q->BF = 0;
            return 2;
        case EH:
            vPAVLTreeNode_Q->BF = -1;
            return 1;
        case RH:
            RightBalance(vPAVLTreeNode_P);
        }
    }
    else {
        vPAVLTreeNode_P->data = vPAVLTreeNode_Q->data;
        vPAVLTreeNode_P = vPAVLTreeNode_Q;
        vPAVLTreeNode_Q = vPAVLTreeNode_Q->pRChild;
        return 2;
    }
    return 0;
}
//中序遍历函数
template<class T>
void AVLTree<T>::PrintAVLTree(AVLTreeNode<T>* vAVLTreeNode)
{
    if (vAVLTreeNode == NULL) return;
    PrintAVLTree(vAVLTreeNode->pLChild);//先遍历左子树
    cout << vAVLTreeNode->data << " ";//输出根节点
    PrintAVLTree(vAVLTreeNode->pRChild);//再遍历右子树
}
//中序遍历接口
template<class T>
void AVLTree<T>::PrintAVLTree()
{
    PrintAVLTree(pAVLTreeRoot);
}
template <class T>
void AVLTree<T>::LeftHorzShow()
{
    LeftHorzShow(pAVLTreeRoot, 0);
}
template <class T>
void AVLTree<T>::LeftHorzShow(AVLTreeNode<T>* vAVLTreeNode, int nLayer)
{
    if (vAVLTreeNode == NULL)
        return;
    else
    {
        LeftHorzShow(vAVLTreeNode->pRChild, nLayer + 1);
        for (int i = 0; i < nLayer; i++)
            cout << "      ";
        cout << vAVLTreeNode->data << endl;
        LeftHorzShow(vAVLTreeNode->pLChild, nLayer + 1);
    }
}
void main()
{
    AVLTree<int> tempAVLTree;
    int tempDataSet[10] = { 1,2,3,4,5,6,7,8,9,10 };
    for (int i = 0; i < 10; i++)
    {
        cout << "插入结点:" << tempDataSet[i] << endl;
        tempAVLTree.InsertAVLTreeNode(tempDataSet[i]);
        cout << "横向输出 AVL 树:" << endl;
        tempAVLTree.LeftHorzShow();
        cout << endl;
    }
    cout << "删除结点:" << tempDataSet[5] << endl;
    tempAVLTree.DeleteAVLTreeNode(tempDataSet[5]);
    tempAVLTree.LeftHorzShow();
    cout << endl;
    system("pause");
}
NineZc
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
AVLtree_c_avl_平衡二叉树_avltree_
10-02
将平衡二叉树的增删改查集成到了一起，提供友好的界面。
【数据结构基础】树 - 平衡二叉树(AVL)
DeveloperFire的博客
02-01 3696
平衡二叉树（Balanced Binary Tree）具有以下性质：它是一棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。平衡二叉树的常用实现方法有红黑树、AVL、替罪羊树、Treap、伸展树等。 最小二叉平衡树的节点的公式如下 F(n)=F(n-1)+F(n-2)+1 这个类似于一个递归的数列，可以参考Fibonacci数列，1是根节点，F(n-1)是左子树的节点数量，F(n-2)是右子树的节点数量。
AVL树的旋转图解和简单实现
热门推荐
喵了个呜的博客
07-07 4万+
AVL树是带有平衡条件的查找二叉树。这个平衡条件要容易保持，而且他要保证树的深度为O(logN) 原文地址：http://blog.csdn.net/qq_25806863/article/details/74755131 平衡条件 一个最理想的平衡条件是左右两个子树的高度完全相等，但只有节点数量为2^n-1的树才满足这个条件（n是层数，2层要3个，3层要7个）。这个条件太严格，不好用。...
AVL树插入、删除的分析与实现
有点甜
07-10 4320
AVL树基本概念 首先，AVL树也是一种
AVL树详解
wanglelelihuanhuan的专栏
07-08 1万+
AVL树定义： AVL树又称为高度平衡的二叉搜索树。它能保持二叉树的高度平衡，尽量降低二叉树的高度，减少树的平均搜索长度。 AVL树性质： 左子树和右子树的高度之差的绝对值不超过1树中的每个左子树和右子树都是AVL树每个节点都有一个平衡因子(balance factor--bf),任一节点的平衡因子是-1,0,1。(每个节点的平衡因子等于右子树的高度减去左子树的高度 )     AV
数据结构 - AVLTree
xd6905的博客
05-10 175
目录 一、概念 二、实现 2.1 节点 2.2 树 2.3 插入 2.4 旋转 2.4.1 左旋 2.4.2 右旋 2.4.3 右左双旋 2.4.4 左右双旋 2.5 验证 一、概念 AVL树来源于二叉搜索树。当二叉搜索树是以下单支的情况下，搜索效率退化为O(n)。为了解决这个问题，我们通过一些手段将二叉搜索树左右平衡（每一个节点的左右子树高度差不大于1），这样平衡的二叉搜索树就是AVL树。 为了更好地实现AVL树，我们引入平衡因子（bal...
AVL数（平衡二叉树） C++实现
Nick
11-20 724
一般的二叉搜索树，在使用的过程中可能会慢慢变得不平衡，这样很可能会降低查找、插入等等的效率，因此我们需要使用算法来实现树的平衡。AVL树是一种比较经典的平衡二叉搜索树，它规定每个节点的左子树和右子树的高度差最多为1，代码如下。（参考博客中对remove函数的书写存在一定的问题，忘记在最后对每个结点进行height的更新，本文代码对此做出来修改，并用实例测试得以验证） avl.h #ifndef A...
【c++】AVL树详解
LLZK_的博客
10-30 2188
AVL树是又叫平衡二叉搜索树，但是它不是完全平衡，只是近似平衡（高度平衡）。什么叫完全平衡？想象一下完全二叉树。 根据名字’二叉搜索树‘，我们可以知道它的一些性质： 1. 每个节点都有一个作为搜索依据的关键码（key），所有节点的关键码互不相同。 2. 左子树上所有节点的关键码（key）都小于根节点的关键码（key）。 3. 右子树上所有节点的关键码（key）都大于根节点的关键码（key）
03平衡二叉树_AVLTree.rar_03平衡二叉树_AVLTree_大话数据结构_平衡二叉树
09-21
查找算法，平衡二叉树，大话数据结构里面的。
AVL tree 平衡二叉树
03-17
AVL tree的数据结构例程，参考《数据结构与算法分析——C语言版》，书上代码整理成为一个可运行C程序文件
AVLTree 平衡二叉树c++实现
06-26
c++平衡二叉树的实现 带内存分配，非常全面 ，有错误欢迎留言
AVLTree自平衡二叉树C++模板类实现
01-19
使用C++实现的AVLTree自平衡二叉树，支持动态插入与删除操作，供C++数据结构课程学习与交流使用。
Kruskal算法+邻接矩阵
NineZc的博客
01-17 2280
// Kruskal.cpp : 定义控制台应用程序的入口点。 // #include "stdafx.h" #include #include #include #include using namespace std; struct EdgeNode { int from; int to; int weight; friend bool operator//自
单链表 尾插入法
NineZc的博客
10-19 1131
数据结构 单链表+尾插入构造函数
二叉树（前序遍历+中序遍历+后序遍历）递归
NineZc的博客
01-16 579
// BinaryTree.cpp : 定义控制台应用程序的入口点。 // #include "stdafx.h" #include #include #include using namespace std; template class T> struct BiNode //二叉树的结点结构 { T data; BiNode *lchild, *rchild; }; t
关键路径+拓扑排序+递归遍历顶点+广度优先遍历图+邻接储存
NineZc的博客
01-17 471
// CriticalPath.cpp : 定义控制台应用程序的入口点。 // #include"stdafx.h" #include #include #include #include #include using namespace std; struct ArcNode//定义弧表结点 { int adjVex;//邻接点域 int weight;//弧的权值
哈夫曼树+哈夫曼编码
NineZc的博客
01-17 442
// HuffmanTree.cpp : 定义控制台应用程序的入口点。 // #include "stdafx.h" #include #include using namespace std; struct element { int weight; char f; int lchild, rchild, parent; }; void Select(element
c语言创建平衡二叉树
最新发布
12-13
以下是C语言创建平衡二叉树的示例代码： ```c #include <stdio.h> #include <stdlib.h> // 定义平衡二叉树结点 typedef struct AVLNode { int data; // 数据域 int height; // 结点高度 struct AVLNode *left; // 左子树指针 struct AVLNode *right; // 右子树指针 } AVLNode, *AVLTree; // 获取结点高度 int getHeight(AVLTree T) { if (T == NULL) { return -1; } else { return T->height; } } // 获取两个数中的最大值 int max(int a, int b) { return a > b ? a : b; } // LL旋转 AVLTree LLRotation(AVLTree A) { AVLTree B = A->left; A->left = B->right; B->right = A; A->height = max(getHeight(A->left), getHeight(A->right)) + 1; B->height = max(getHeight(B->left), A->height) + 1; return B; } // RR旋转 AVLTree RRRotation(AVLTree A) { AVLTree B = A->right; A->right = B->left; B->left = A; A->height = max(getHeight(A->left), getHeight(A->right)) + 1; B->height = max(getHeight(B->right), A->height) + 1; return B; } // LR旋转 AVLTree LRRotation(AVLTree A) { A->left = RRRotation(A->left); return LLRotation(A); } // RL旋转 AVLTree RLRotation(AVLTree A) { A->right = LLRotation(A->right); return RRRotation(A); } // 插入结点 AVLTree insert(AVLTree T, int data) { if (T == NULL) { T = (AVLTree)malloc(sizeof(AVLNode)); T->data = data; T->height = 0; T->left = T->right = NULL; } else if (data < T->data) { T->left = insert(T->left, data); if (getHeight(T->left) - getHeight(T->right) == 2) { if (data < T->left->data) { T = LLRotation(T); } else { T = LRRotation(T); } } } else if (data > T->data) { T->right = insert(T->right, data); if (getHeight(T->right) - getHeight(T->left) == 2) { if (data > T->right->data) { T = RRRotation(T); } else { T = RLRotation(T); } } } T->height = max(getHeight(T->left), getHeight(T->right)) + 1; return T; } // 中序遍历 void inorderTraversal(AVLTree T) { if (T != NULL) { inorderTraversal(T->left); printf("%d ", T->data); inorderTraversal(T->right); } } int main() { AVLTree T = NULL; int arr[] = {3, 2, 1, 4, 5, 6, 7, 10, 9, 8}; int len = sizeof(arr) / sizeof(arr[0]); for (int i = 0; i < len; i++) { T = insert(T, arr[i]); } inorderTraversal(T); // 输出：1 2 3 4 5 6 7 8 9 10 return 0; } ```

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值